import java.io.*;


public class ej23 {
	
//	Métodos a utilizar
	public static float potencia(float base, float exponente){ /* Función potencia para realizar potencias de
			* distintas bases de forma fácil.*/
		float resultado=1;
		int i;
		for(i=1;i<=exponente;i++)
			resultado=resultado*base;

		return resultado;
	}
	
	
	public static void main(String[] args) throws IOException{
		//Constantes, tamaño de los arrays referidos a operadores y números
		final int operadores_totales = 10;
		final int numeros_totales = 10;
		
		//Variables
		int i,j; //Iteradores
		int n_op = 0;//contador de operadores
		int n_num = 0; //contador de numeros
		float numero[] = new float [numeros_totales];
		float acumulado=0; //acumula los sucesivos resultados de las operaciones
		char op[] = new char[operadores_totales]; //almacena los operadores por orden
		char entradaC[];
		
		String[] numeroS = new String [numeros_totales]; //Strings donde se almacenarán los números leidos
														 // poco a poco de la cadena de carácteres.

		String entrada;//String donde se almacenará lo introducido por teclado
		
		
		InputStreamReader teclado; //Declaro la entrada de datos
		BufferedReader bufferLectura;//Declaro Buffer de entrada
		
		

		
		teclado = new InputStreamReader (System.in);//Paso al InputStreamReader la entrada de teclado 
		bufferLectura = new BufferedReader (teclado);//Se almacena en el buffer
		
		System.out.println("\tOPERACIONES POSIBLES\n- Suma:\t\t\t \"+\"\n- Resta:\t\t \"-\"\n- Multiplicación:\t \"*\"\n- División:\t\t \"/\"\n- Potencia:\t\t \"**\" (después debe ponerse el exponente)\n\tEj. 3³ + 5 = 3**3+5");
		System.out.print("Introduce la operación: ");
		entrada = bufferLectura.readLine(); //Paso al String la línea introducida a través del Buffer
				
		//Convierto el String en un ARRAY de carácteres
		entradaC = new char [entrada.length()];
		for(i=0;i<entrada.length();i++)
			entradaC[i] = entrada.charAt(i);
		

		//Recorre el Array buscando los operadores y almacenándolos en orden.
		for(i=0;i<entrada.length();i++){
			//si se encuentra un operador
			if(entradaC[i]=='/'||entradaC[i]=='-'||entradaC[i]=='+'){
				op[n_op] = entradaC[i]; //pasa el símbolo al vector de operadores
				n_op++; //avanza una posición en el vector
			}
			else if(entradaC[i]=='*'){ //Trata a la multiplicación como caso aparte
				if (entradaC[i+1]=='*'){
					op[n_op] = '^'; //si hay dos * seguidos, almacena la potencia
					n_op++;	// y avanza lugar en el operador
					i++; //Se salta un lugar en el iterador, puesto que el siguiente también va a ser *
				}
				else {
					op[n_op] = '*'; //sino es una potencia, sino un *, actúa como en los demas casos
					n_op++;
				}
			}
		}
	
		//ANTES de manejar el Array de strings, inicializo todos
		//sus valores a "" (nada), para evitar posteriores errores "null"
		for(i=0;i<=9;i++)
			numeroS[i]= "";

		
		//Recorre el Array buscando los números y almacenándolos en orden.
		for(i=0;i<entrada.length();i++){
			if(entradaC[i]=='/'||entradaC[i]=='-'||entradaC[i]=='+'){
				//Si llega hasta un operador, se lo salta y avanza al siguiente número
				// del array de Strings
				n_num++;
			}
			else if(entradaC[i]=='*'){ //ahora hay que tener en cuenta el **, si encuentra un * evalúa si se
									// tiene que saltar 1 o dos posiciones
			
				if(entradaC[i+1]=='*'||entradaC[i]=='/'||entradaC[i]=='-'||entradaC[i]=='+'){
							//si hay otro símbolo adicional, avanza posiciones adicionales
					i++;
					n_num++;
				}
				else n_num++;
				
			}
			
			else numeroS[n_num]+=String.valueOf(entradaC[i]);
		}
		//Transforma los strings de números a un vector de enteros
		for(i=0;i<=n_num;i++){
			if (numeroS[i]!="") //evita que intente evaluar Strings de números vacíos
				numero[i] = Float.parseFloat(numeroS[i]);
		}
		
		//Una vez con los números puestos en el array numero[] de tamaño n_num
		//y con los operadores en op[] de tamaño n_op, se hacen las operaciones
		//Al haber un nuevo operador, se ha incluido la funcion POTENCIA fuera del main
		//que será llamada cuando haya que realizar potencias.
		
		acumulado=numero[0]; //Inicia el acumulado al primer número de la cadena
		for (i=0,j=1;i<=n_op;i++,j++ ){ 
			
			//La variable i, se corresponde con el número del operador
			//La variable j, se corresponde con la posición del número.
			if (op[i]=='+')
				acumulado = acumulado + numero[j];
			else if (op[i]=='-')
				acumulado = acumulado - numero[j];
			else if (op[i]=='*')
				acumulado = acumulado * numero[j];
			else if (op[i]=='/')
				acumulado = acumulado / numero[j];
			else if(op[i]=='^')
				acumulado = potencia(acumulado,numero[j]);
				
		}
		System.out.println("RESULTADO: "+acumulado);
	}

}
